9 research outputs found
Improved Online Algorithm for Weighted Flow Time
We discuss one of the most fundamental scheduling problem of processing jobs
on a single machine to minimize the weighted flow time (weighted response
time). Our main result is a -competitive algorithm, where is the
maximum-to-minimum processing time ratio, improving upon the
-competitive algorithm of Chekuri, Khanna and Zhu (STOC 2001). We
also design a -competitive algorithm, where is the
maximum-to-minimum density ratio of jobs. Finally, we show how to combine these
results with the result of Bansal and Dhamdhere (SODA 2003) to achieve a
-competitive algorithm (where is the
maximum-to-minimum weight ratio), without knowing in advance. As shown
by Bansal and Chan (SODA 2009), no constant-competitive algorithm is achievable
for this problem.Comment: 20 pages, 4 figure
Improved and Deterministic Online Service with Deadlines or Delay
We consider the problem of online service with delay on a general metric
space, first presented by Azar, Ganesh, Ge and Panigrahi (STOC 2017). The best
known randomized algorithm for this problem, by Azar and Touitou (FOCS 2019),
is -competitive, where is the number of points in the metric
space. This is also the best known result for the special case of online
service with deadlines, which is of independent interest.
In this paper, we present -competitive deterministic algorithms
for online service with deadlines or delay, improving upon the results from
FOCS 2019. Furthermore, our algorithms are the first deterministic algorithms
for online service with deadlines or delay which apply to general metric spaces
and have sub-polynomial competitiveness.Comment: Appears in STOC 202
Frameworks for Nonclairvoyant Network Design with Deadlines or Delay
Clairvoyant network design with deadlines or delay has been studied extensively, culminating in an O(log n)-competitive general framework, where n is the number of possible request types (Azar and Touitou, FOCS 2020). In the nonclairvoyant setting, the problem becomes much harder, as ?(?n) lower bounds are known for certain problems (Azar et al., STOC 2017). However, no frameworks are known for the nonclairvoyant setting, and previous work focuses only on specific problems, e.g., multilevel aggregation (Le et al., SODA 2023).
In this paper, we present the first nonclairvoyant frameworks for network design with deadlines or delay. These frameworks are nearly optimal: their competitive ratio is O?(?n), which matches known lower bounds up to logarithmic factors
Set Cover with Delay - Clairvoyance Is Not Required
In most online problems with delay, clairvoyance (i.e. knowing the future delay of a request upon its arrival) is required for polylogarithmic competitiveness. In this paper, we show that this is not the case for set cover with delay (SCD) - specifically, we present the first non-clairvoyant algorithm, which is O(log n log m)-competitive, where n is the number of elements and m is the number of sets. This matches the best known result for the classic online set cover (a special case of non-clairvoyant SCD). Moreover, clairvoyance does not allow for significant improvement - we present lower bounds of ?(?{log n}) and ?(?{log m}) for SCD which apply for the clairvoyant case.
In addition, the competitiveness of our algorithm does not depend on the number of requests. Such a guarantee on the size of the universe alone was not previously known even for the clairvoyant case - the only previously-known algorithm (due to Carrasco et al.) is clairvoyant, with competitiveness that grows with the number of requests.
For the special case of vertex cover with delay, we show a simpler, deterministic algorithm which is 3-competitive (and also non-clairvoyant)
Competitive Vertex Recoloring
Motivated by placement of jobs in physical machines, we introduce and analyze the problem of online recoloring, or online disengagement. In this problem, we are given a set of n weighted vertices and a k-coloring of the vertices (vertices represent jobs, and colors represent physical machines). Edges, representing conflicts between jobs, are inserted in an online fashion. After every edge insertion, the algorithm must output a proper k-coloring of the vertices. The cost of a recoloring is the sum of weights of vertices whose color changed. Our aim is to minimize the competitive ratio of the algorithm, i.e., the ratio between the cost paid by the online algorithm and the cost paid by an optimal, offline algorithm.
We consider a couple of polynomially-solvable coloring variants. Specifically, for 2-coloring bipartite graphs we present an O(log n)-competitive deterministic algorithm and an ?(log n) lower bound on the competitive ratio of randomized algorithms. For (?+1)-coloring, we present tight bounds of ?(?) and ?(log?) on the competitive ratios of deterministic and randomized algorithms, respectively (where ? denotes the maximum degree). We also consider a dynamic case which allows edge deletions as well as insertions. All our algorithms are applicable to the case where vertices are weighted and the cost of recoloring a vertex is its weight. All our lower bounds hold even in the unweighted case
Flow time scheduling with uncertain processing time
We consider the problem of online scheduling on a single machine in order to minimize weighted flow time. The existing algorithms for this problem (STOC ’01, SODA ’03, FOCS ’18) all require exact knowledge of the processing time of each job. This assumption is crucial, as even a slight perturbation of the processing time would lead to polynomial competitive ratio. However, this assumption very rarely holds in real-life scenarios.
In this paper, we present the first algorithm for weighted flow time which do not require exact knowledge of the processing times of jobs. Specifically, we introduce the Scheduling with Predicted Processing Time (SPPT) problem, where the algorithm is given a prediction for the processing time of each job, instead of its real processing time. For the case of a constant factor distortion between the predictions and the real processing time, our algorithms match all the best known competitiveness bounds for weighted flow time – namely O(logP), O(logD) and O(logW), where P,D,W are the maximum ratios of processing times, densities, and weights, respectively. For larger errors, the competitiveness of our algorithms degrades gracefully